#include "customfilebrowser.h"
#include "customfileitem.h"  // 添加完整的 CustomFileItem 头文件
#include "layoutstatemanager.h"
#include "systemconfigmanager.h"
#include "filestatusiconmanager.h"
#include "unifiedcachemanager.h"
#include "memorycachemanager.h"
#include "fileidentitymanager.h"
#include "unifiedfileinfo.h"
#include "filelistcontextmenu.h"
#include "naturalsortcomparator.h"
#include "fileprocessworker.h"
#include <QVBoxLayout>
#include <QDateTime>
#include <QFileInfo>
#include <QDebug>
#include <QMutexLocker>
#include <QPointer>
#include <QTimer>
CustomFileBrowser::CustomFileBrowser(QWidget *parent)
    : QWidget(parent)
    , m_customFileList(new CustomFileListWidget(this))
    , m_currentIndex(-1)
    , m_mainWindowCurrentFile(-1)
    , m_contextMenu(new FileListContextMenu(this))
{
    setupUI();
    connectSignals();
}

CustomFileBrowser::~CustomFileBrowser()
{
    // === 关键补充：析构时取消所有后台任务 ===
    QMutexLocker locker(&m_workersMutex);
    for (auto it = m_activeWorkers.begin(); it != m_activeWorkers.end(); ++it) {
        QPointer<FileProcessWorker> worker = it.value();
        if (worker) {
            worker->cancel();
        }
    }
    m_activeWorkers.clear();
    locker.unlock();
    
    // 断开所有信号连接，防止析构过程中触发回调
    disconnect(this, nullptr, nullptr, nullptr);
}

void CustomFileBrowser::setupUI()
{
    // 创建主布局
    QVBoxLayout* layout = new QVBoxLayout(this);
    layout->setContentsMargins(0, 0, 0, 0);
    layout->addWidget(m_customFileList);
    setLayout(layout);
    // 设置此控件的尺寸策略，允许水平和垂直方向的调整
    setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
    // 初始化自适应模式
    if (m_adaptiveMode && m_customFileList) {
        m_customFileList->setAdaptiveMode(true);
        // 设置窗口的默认尺寸限制
        setMinimumWidth(m_minWidth);
        if (m_maxWidth > 0) {
            setMaximumWidth(m_maxWidth);
        }
        // 设置默认尺寸
        resize(CustomFileItem::DEFAULT_ITEM_WIDTH, 400);
    }
}
void CustomFileBrowser::connectSignals()
{
    // 连接新的简化信号到业务逻辑处理
    connect(m_customFileList, &CustomFileListWidget::itemClicked,
            this, &CustomFileBrowser::onItemClicked);
    connect(m_customFileList, &CustomFileListWidget::itemRightClicked,
            this, &CustomFileBrowser::onItemRightClicked);
    connect(m_customFileList, &CustomFileListWidget::itemDragRequested,
            this, &CustomFileBrowser::handleDragOperation);
    connect(m_customFileList, &CustomFileListWidget::selectionChanged,
            this, &CustomFileBrowser::onSelectionChanged);
    // 连接统一状态管理器信号（复刻原FileBrowser行为）
    connect(LayoutStateManager::instance(), &LayoutStateManager::layoutModeChanged,
            this, &CustomFileBrowser::onLayoutModeChanged);
    connect(LayoutStateManager::instance(), &LayoutStateManager::displayRefreshNeeded,
            this, &CustomFileBrowser::onDisplayRefreshNeeded);
}
// 文件管理接口实现
void CustomFileBrowser::addFile(const QString& filePath)
{
    UnifiedFileInfo fileInfo = createFileInfo(filePath);
    // === Martin Fowler重构：设置新文件的位置信息 ===
    fileInfo.displayOrder = m_files.size(); // 新文件添加到末尾
    m_files.append(fileInfo);
    // 刷新UI以显示新文件
    m_customFileList->refreshUI(QList<int>());
    emit filesChanged();
    updateTotalDisplayPages(); // 通知总页数变化
    notifyExportAvailability(); // Martin Fowler重构：通知导出可用性变化
}
void CustomFileBrowser::addFiles(const QStringList& filePaths)
{
    for (const QString& path : filePaths) {
        addFile(path);
    }
    // 添加完所有文件后，确保第一个文件被选中
    if (!m_files.isEmpty() && filePaths.size() > 1) {
        selectFile(0);  // 选择第一个文件
    }
}
void CustomFileBrowser::removeFile(int index)
{
    // 添加文件列表状态检查，防止访问无效内存
    if (m_files.isEmpty()) {
        return;
    }

    if (index < 0 || index >= m_files.size()) {
        return;
    }
    // 在移除文件前，先清理对应的缓存（复刻原FileBrowser行为）
    const UnifiedFileInfo& fileInfo = m_files[index];
    if (!fileInfo.filePath.isEmpty()) {
        // === 关键补充：取消该文件的后台处理任务 ===
        if (!fileInfo.fileIdentity.isEmpty()) {
            cancelWorkerForFile(fileInfo.fileIdentity);
        }
        
        // === Martin Fowler重构：使用文件级缓存路径清理 ===
        UnifiedCacheManager* cacheManager = UnifiedCacheManager::instance();
        if (cacheManager) {
            cacheManager->clearFileCacheWithFileInfo(fileInfo);
        }
        // === 补完文件清理机制：清理内存缓存 ===
        MemoryCacheManager* memoryCache = MemoryCacheManager::instance();
        if (memoryCache) {
            memoryCache->clearFileCache(fileInfo.fileIdentity);
        }
        // === 补完文件清理机制：清理布局状态记录 ===
        LayoutStateManager* layoutManager = LayoutStateManager::instance();
        if (layoutManager) {
            layoutManager->removeFileState(fileInfo.fileIdentity);
        }
          // === Martin Fowler重构：移除全局页码映射 ===
        removeGlobalPageMapping(fileInfo.fileIdentity);
    }
    // === Martin Fowler重构：使用统一的当前索引调整策略 ===
    int newCurrentIndex = calculateNewCurrentIndexAfterDeletion({index}, m_currentIndex);
    m_files.removeAt(index);
    // 使用统一的索引调整策略
    m_currentIndex = newCurrentIndex;
    m_mainWindowCurrentFile = m_currentIndex; // 同步主窗口当前文件状态
    // === 关键修复：单个文件删除后也应该单选，不保持多选状态 ===
    refreshUIAfterFileDeletion();
    emit fileRemoved(index);
    emit filesChanged();
    updateTotalDisplayPages(); // 通知总页数变化
    notifyExportAvailability(); // Martin Fowler重构：通知导出可用性变化
}
void CustomFileBrowser::clearFiles()
{
    // 在清空文件前，先清理所有缓存（复刻原FileBrowser行为）
    if (!m_files.isEmpty()) {
        // === 关键补充：取消所有后台处理任务 ===
        QMutexLocker locker(&m_workersMutex);
        for (auto it = m_activeWorkers.begin(); it != m_activeWorkers.end(); ++it) {
            QPointer<FileProcessWorker> worker = it.value();
            if (worker) {
                worker->cancel();
            }
        }
        m_activeWorkers.clear();
        locker.unlock();
        
        // 通过统一缓存管理器清除所有缓存
        UnifiedCacheManager* cacheManager = UnifiedCacheManager::instance();
        if (cacheManager) {
            cacheManager->clearAllCache();
        }
        // === Martin Fowler重构：清空所有全局页码映射 ===
        GlobalPageManager& globalPageManager = GlobalPageManager::instance();
        globalPageManager.clearAllFileInfo();
    }
    m_files.clear();
    m_customFileList->refreshUI(QList<int>());
    // === Martin Fowler重构：统一状态管理 ===
    setCurrentIndex(-1);
    m_mainWindowCurrentFile = -1; // 同步主窗口当前文件状态
    emit filesChanged();
    updateTotalDisplayPages(); // 通知总页数变化
    notifyExportAvailability(); // Martin Fowler重构：通知导出可用性变化
}
void CustomFileBrowser::removeFileInternal(int index)
{
    if (index < 0 || index >= m_files.size()) {
        return;
    }
    // 内部移除方法，不清理缓存（缓存已在批量操作中清理）
    m_files.removeAt(index);
    // 调整当前索引
    if (m_currentIndex >= index && m_currentIndex > 0) {
        m_currentIndex--;
    }
    // 刷新UI以反映文件删除
    m_customFileList->refreshUI(QList<int>());
    emit fileRemoved(index);
    emit filesChanged();
    updateTotalDisplayPages(); // 通知总页数变化
}
void CustomFileBrowser::selectFile(int index)
{
    if (index < 0 || index >= m_files.size()) {
        return;
    }
    setCurrentIndex(index);
    m_customFileList->updateSelection(index);
}
// 获取文件信息接口实现
QList<UnifiedFileInfo> CustomFileBrowser::getFiles() const
{
    return m_files;
}
UnifiedFileInfo CustomFileBrowser::getFile(int index) const
{
    // 按displayOrder排序后返回指定索引的文件
    QList<UnifiedFileInfo> sortedFiles = m_files;
    std::sort(sortedFiles.begin(), sortedFiles.end(),
              [](const UnifiedFileInfo& a, const UnifiedFileInfo& b) {
                  return a.displayOrder < b.displayOrder;
              });

    if (index >= 0 && index < sortedFiles.size()) {
        return sortedFiles[index];
    }
    return UnifiedFileInfo();
}
int CustomFileBrowser::getCurrentIndex() const
{
    // 验证当前索引的有效性
    if (m_currentIndex < 0 || m_currentIndex >= m_files.size()) {
        // 如果索引无效，返回-1或有效的最后一个索引
        if (m_files.isEmpty()) {
            return -1;
        } else if (m_currentIndex >= m_files.size()) {
            return m_files.size() - 1;  // 返回修正后的索引
        }
    }
    return m_currentIndex;
}
void CustomFileBrowser::setCurrentIndex(int index)
{
    // 验证索引有效性
    if (index < -1 || index >= m_files.size()) {
        return;
    }
    if (m_currentIndex != index) {
        int oldIndex = m_currentIndex;
        m_currentIndex = index;
    }
}
QString CustomFileBrowser::getCurrentFileIdentity() const
{
    if (m_currentIndex >= 0 && m_currentIndex < m_files.size()) {
        return m_files[m_currentIndex].fileIdentity;
    }
    return QString();
}
int CustomFileBrowser::getFileCount() const
{
    return m_files.size();
}
// 文件设置接口实现
void CustomFileBrowser::updateFileSettings(int index, const UnifiedFileInfo& settings)
{
    if (index >= 0 && index < m_files.size()) {
        m_files[index] = settings;
        emit settingsChanged(index, settings);
    }
}
void CustomFileBrowser::setGlobalSettings(const UnifiedFileInfo& settings)
{
    m_globalSettings = settings;
}
// 缓存元数据设置
void CustomFileBrowser::setProcessedMetadata(int index, const QString& hash, int pages, const QDateTime& latest)
{
    if (index >= 0 && index < m_files.size()) {
        // 更新FileInfo的元数据
        m_files[index].fileIdentity = hash;
        m_files[index].pageCount = pages;
        m_files[index].lastModified = latest;
        
        // === 关键修复：页数更新时保持文件的layoutMode，同时同步到LayoutStateManager ===
        // 文件的layoutMode在createFileInfo()时已经从系统配置读取并设置
        // 这里不应该重新读取，否则会覆盖已设置的值
        LayoutMode currentMode = m_files[index].layoutMode;
        
        // 确保LayoutStateManager中也有正确的记录（防御性编程）
        LayoutMode mgrMode = LayoutStateManager::instance()->getFileLayoutMode(hash);
        if (mgrMode != currentMode) {
            LayoutStateManager::instance()->setFileLayoutMode(hash, currentMode);
        }
        
        // 重要：同步更新CustomFileListWidget的显示
        updateFileDisplayAt(index);
        // 计算显示页数并更新全局页码映射
        LayoutMode mode = LayoutStateManager::convertFromOldLayoutMode(
            UnifiedFileInfo::layoutModeToInt(m_files[index].layoutMode));
        int displayPages = LayoutStateManager::calculateDisplayPages(mode, pages);
        // 更新全局页码映射
        updateGlobalPageMapping(hash, displayPages);
        // 页数变化会影响总页数，通知更新
        updateTotalDisplayPages();
    }
}
// 文件查找和更新
int CustomFileBrowser::getFileIndexByIdentity(const QString& fileIdentity) const
{
    for (int i = 0; i < m_files.size(); ++i) {
        if (m_files[i].fileIdentity == fileIdentity) {
            return i;
        }
    }
    return -1;
}
void CustomFileBrowser::updateFileLayoutMode(int index, int layoutMode)
{
    if (index >= 0 && index < m_files.size()) {
        m_files[index].layoutMode = static_cast<LayoutMode>(layoutMode);
    }
}
int CustomFileBrowser::calculatePageCountForLayout(int basePageCount, int layoutMode) const
{
    // 使用与原FileBrowser相同的计算逻辑
    if (layoutMode == static_cast<int>(LayoutMode::SingleColumn)) {
        return basePageCount;
    } else if (layoutMode == static_cast<int>(LayoutMode::TwoColumns)) {
        return (basePageCount + 1) / 2;
    } else if (layoutMode == static_cast<int>(LayoutMode::ThreeColumns)) {
        return (basePageCount + 2) / 3;
    }
    return basePageCount;
}
QList<int> CustomFileBrowser::getSelectedIndices() const
{
    return m_customFileList->getSelectedIndices();
}
// 显示控制
void CustomFileBrowser::showBrowser()
{
    show();
}
void CustomFileBrowser::hideBrowser()
{
    hide();
}
bool CustomFileBrowser::isVisible() const
{
    return QWidget::isVisible();
}
// 拖拽排序
void CustomFileBrowser::enableDragDrop(bool enable)
{
    // CustomFileListWidget已经支持拖拽，这里可以控制启用/禁用
    Q_UNUSED(enable);
    // TODO: 如果需要，可以在CustomFileListWidget中添加启用/禁用接口
}
// 自适应窗口管理
void CustomFileBrowser::setAdaptiveMode(bool enabled)
{
    if (m_adaptiveMode == enabled) {
        return;
    }
    m_adaptiveMode = enabled;
    // 将自适应模式设置传递给文件列表控件
    if (m_customFileList) {
        m_customFileList->setAdaptiveMode(enabled);
    }
}
bool CustomFileBrowser::isAdaptiveMode() const
{
    return m_adaptiveMode;
}
void CustomFileBrowser::setMinimumWidth(int width)
{
    m_minWidth = qMax(CustomFileItem::MIN_ITEM_WIDTH, width);  // 使用CustomFileItem的最小宽度（150px）
    if (m_adaptiveMode) {
        QWidget::setMinimumWidth(m_minWidth);
    }
}
void CustomFileBrowser::setMaximumWidth(int width)
{
    m_maxWidth = qMax(m_minWidth, width);  // 确保最大宽度不小于最小宽度
    if (m_adaptiveMode) {
        QWidget::setMaximumWidth(m_maxWidth);
    }
}
void CustomFileBrowser::resizeEvent(QResizeEvent* event)
{
    QWidget::resizeEvent(event);
    // 如果启用了自适应模式，响应尺寸变化
    if (m_adaptiveMode && m_customFileList) {
        // 尺寸变化由 CustomFileListWidget 的 resizeEvent 自动处理
        // 这里可以添加其他需要响应尺寸变化的逻辑
    }
}
// 布局模式管理
void CustomFileBrowser::setFileLayoutMode(int index, LayoutMode mode)
{
    if (index >= 0 && index < m_files.size()) {
        QString fileIdentity = m_files[index].fileIdentity;
        if (!fileIdentity.isEmpty()) {
            // 通过统一状态管理器设置布局模式（复刻原FileBrowser行为）
            LayoutStateManager::instance()->setFileLayoutMode(fileIdentity, mode);
            // 同步更新 FileInfo 的布局模式（保持兼容性）
            m_files[index].layoutMode = static_cast<LayoutMode>(LayoutStateManager::convertToOldLayoutMode(mode));
        }
    }
}
LayoutMode CustomFileBrowser::getFileLayoutMode(int index) const
{
    if (index >= 0 && index < m_files.size()) {
        return static_cast<LayoutMode>(m_files[index].layoutMode);
    }
    return LayoutMode::SingleColumn;
}
void CustomFileBrowser::updateFileDisplayAt(int index)
{
    // 更新指定文件的显示状态
    if (index >= 0 && index < m_files.size()) {
        m_customFileList->updateFileItem(index);
    }
}
// 主窗口当前显示文件管理
void CustomFileBrowser::setMainWindowCurrentFile(int index)
{
    m_mainWindowCurrentFile = index;
}
int CustomFileBrowser::getMainWindowCurrentFile() const
{
    return m_mainWindowCurrentFile;
}
// 文件状态管理
void CustomFileBrowser::setFileStatus(int index, FileStatusIconManager::FileStatus status, int progress, const QString& statusText)
{
    if (index >= 0 && index < m_files.size()) {
        m_files[index].status = status;
        m_files[index].progress = progress;
        m_files[index].statusText = statusText;
        // 更新显示状态
        updateFileDisplayAt(index);
        notifyExportAvailability(); // Martin Fowler重构：通知导出可用性变化
    }
}
void CustomFileBrowser::updateFileProgress(int index, int progress, const QString& statusText)
{
    if (index >= 0 && index < m_files.size()) {
        
        m_files[index].progress = progress;
        m_files[index].statusText = statusText;
        // 同步更新两个状态字段
        if (progress > 0 && progress < 100) {
            m_files[index].processStatus = FileProcessStatus::Processing;
            m_files[index].status = FileStatusIconManager::FileStatus::Processing;
        } else if (progress >= 100) {
            m_files[index].processStatus = FileProcessStatus::Completed;
            m_files[index].status = FileStatusIconManager::FileStatus::Completed;
        }
        // 更新显示状态
        updateFileDisplayAt(index);
        notifyExportAvailability(); // Martin Fowler重构：通知导出可用性变化
    }
}
void CustomFileBrowser::setFileCompleted(int index)
{
    setFileStatus(index, FileStatusIconManager::FileStatus::Completed, 100, tr("已完成"));
}
void CustomFileBrowser::setFileError(int index, const QString& errorMessage)
{
    setFileStatus(index, FileStatusIconManager::FileStatus::Error, 0,
                 errorMessage.isEmpty() ? tr("处理错误") : errorMessage);
}

// === 基于文件身份的状态管理（排序安全）===
int CustomFileBrowser::findIndexByFileIdentity(const QString& fileIdentity) const
{
    for (int i = 0; i < m_files.size(); ++i) {
        if (m_files[i].fileIdentity == fileIdentity) {
            return i;
        }
    }
    return -1;
}

void CustomFileBrowser::setFileStatusByIdentity(const QString& fileIdentity,
    FileStatusIconManager::FileStatus status, int progress, const QString& statusText)
{
    int index = findIndexByFileIdentity(fileIdentity);
    if (index >= 0) {
        setFileStatus(index, status, progress, statusText);
    } else {
    }
}

void CustomFileBrowser::updateFileProgressByIdentity(const QString& fileIdentity,
    int progress, const QString& statusText)
{
    int index = findIndexByFileIdentity(fileIdentity);
    if (index >= 0) {
        updateFileProgress(index, progress, statusText);
    } else {
    }
}

QString CustomFileBrowser::getFileIdentityByIndex(int index) const
{
    if (index >= 0 && index < m_files.size()) {
        return m_files[index].fileIdentity;
    }
    return QString();
}

// === 关键补充：后台任务管理实现 ===
void CustomFileBrowser::registerWorker(const QString& fileIdentity, FileProcessWorker* worker)
{
    if (fileIdentity.isEmpty() || !worker) {
        return;
    }
    
    QMutexLocker locker(&m_workersMutex);
    m_activeWorkers[fileIdentity] = QPointer<FileProcessWorker>(worker);
}

void CustomFileBrowser::unregisterWorker(const QString& fileIdentity)
{
    if (fileIdentity.isEmpty()) {
        return;
    }
    
    QMutexLocker locker(&m_workersMutex);
    m_activeWorkers.remove(fileIdentity);
}

void CustomFileBrowser::cancelWorkerForFile(const QString& fileIdentity)
{
    if (fileIdentity.isEmpty()) {
        return;
    }
    
    QMutexLocker locker(&m_workersMutex);
    if (m_activeWorkers.contains(fileIdentity)) {
        QPointer<FileProcessWorker> worker = m_activeWorkers[fileIdentity];
        if (worker) {
            // 取消worker的处理
            worker->cancel();
        }
        m_activeWorkers.remove(fileIdentity);
    }
}

int CustomFileBrowser::getActiveWorkerCount() const
{
    QMutexLocker locker(const_cast<QMutex*>(&m_workersMutex));
    // 清理已失效的QPointer
    int count = 0;
    for (const QPointer<FileProcessWorker>& worker : m_activeWorkers) {
        if (worker) {
            count++;
        }
    }
    return count;
}

void CustomFileBrowser::refreshFileIcons()
{
    // 刷新所有文件的显示状态
    for (int i = 0; i < m_files.size(); ++i) {
        updateFileDisplayAt(i);
    }
}

// === Martin Fowler重构：Extract Method - 统一的当前索引调整策略 ===
int CustomFileBrowser::calculateNewCurrentIndexAfterDeletion(const QList<int>& deletedIndices, int currentIndex) const
{
    if (deletedIndices.isEmpty()) {
        return currentIndex;
    }
    // 创建删除索引的集合，用于快速查找
    QSet<int> deletedSet(deletedIndices.begin(), deletedIndices.end());
    // 如果当前索引被删除
    if (deletedSet.contains(currentIndex)) {
        // 计算删除后的文件总数
        int newFileCount = m_files.size() - deletedIndices.size();
        if (newFileCount == 0) {
            return -1; // 没有文件了
        }
        // 寻找当前索引之后第一个未被删除的文件
        for (int i = currentIndex + 1; i < m_files.size(); ++i) {
            if (!deletedSet.contains(i)) {
                // 计算这个索引在删除后的新位置
                int newIndex = i;
                for (int deletedIndex : deletedIndices) {
                    if (deletedIndex < i) {
                        newIndex--;
                    }
                }
                return newIndex;
            }
        }
        // 如果当前索引之后没有文件，选择最后一个有效文件
        int newIndex = newFileCount - 1;
        return qMax(0, newIndex);
    }
    // 如果当前索引未被删除，计算其在删除后的新位置
    int newIndex = currentIndex;
    for (int deletedIndex : deletedIndices) {
        if (deletedIndex < currentIndex) {
            newIndex--;
        }
    }
    // 确保新索引在有效范围内
    int newFileCount = m_files.size() - deletedIndices.size();
    newIndex = qMax(0, qMin(newIndex, newFileCount - 1));
    return newIndex;
}
// === 新的信号槽方法实现 ===
void CustomFileBrowser::onItemClicked(int index)
{
    if (index >= 0 && index < m_files.size()) {
        setCurrentIndex(index);
        emit fileSelected(index, m_files[index]);
    } else {
    }
}
void CustomFileBrowser::onItemRightClicked(int index, const QPoint& globalPos)
{
    // 获取选中的文件索引
    QList<int> selectedIndices = m_customFileList->getSelectedIndices();
    // 如果没有选中任何文件，或者右键的文件不在选中列表中，则选中当前右键的文件
    if (selectedIndices.isEmpty() || (index >= 0 && !selectedIndices.contains(index))) {
        selectedIndices.clear();
        selectedIndices.append(index);
        m_customFileList->updateSelection(index);
    }
    // 创建并显示菜单
    QMenu* menu = m_contextMenu->createUnifiedMenu(selectedIndices, index);
    // 连接菜单信号到当前对象的处理函数
    connectContextMenuSignals();
    // 在指定位置显示菜单
    menu->exec(globalPos);
    // 清理菜单
    menu->deleteLater();
}
void CustomFileBrowser::onSelectionChanged(const QList<int>& selectedIndices)
{
    emit selectionChanged(selectedIndices);
}
void CustomFileBrowser::connectContextMenuSignals()
{
    // 连接菜单信号到处理函数
    connect(m_contextMenu, &FileListContextMenu::removeFilesRequested,
            this, &CustomFileBrowser::handleRemoveFiles, Qt::UniqueConnection);
    connect(m_contextMenu, &FileListContextMenu::exportSingleRequested,
            this, &CustomFileBrowser::handleExportSingle, Qt::UniqueConnection);
    connect(m_contextMenu, &FileListContextMenu::exportMultipleRequested,
            this, &CustomFileBrowser::handleExportMultiple, Qt::UniqueConnection);
    connect(m_contextMenu, &FileListContextMenu::exportMergedRequested,
            this, &CustomFileBrowser::handleExportMerged, Qt::UniqueConnection);
    connect(m_contextMenu, &FileListContextMenu::moveToTopRequested,
            this, &CustomFileBrowser::handleMoveToTop, Qt::UniqueConnection);
    connect(m_contextMenu, &FileListContextMenu::moveToBottomRequested,
            this, &CustomFileBrowser::handleMoveToBottom, Qt::UniqueConnection);
    // 添加缺失的全选和取消选择信号连接
    connect(m_contextMenu, &FileListContextMenu::selectAllRequested,
            this, &CustomFileBrowser::handleSelectAll, Qt::UniqueConnection);
    connect(m_contextMenu, &FileListContextMenu::clearSelectionRequested,
            this, &CustomFileBrowser::handleClearSelection, Qt::UniqueConnection);

    // 添加排序信号连接
    connect(m_contextMenu, &FileListContextMenu::naturalSortRequested,
            this, &CustomFileBrowser::handleNaturalSort, Qt::UniqueConnection);
    connect(m_contextMenu, &FileListContextMenu::reverseSortRequested,
            this, &CustomFileBrowser::handleReverseSort, Qt::UniqueConnection);
}
// === Martin Fowler重构：业务逻辑处理方法实现 ===
void CustomFileBrowser::handleRemoveFiles(const QList<int>& indices)
{
    if (indices.isEmpty()) {
        return;
    }

    // 添加文件列表状态检查，防止访问无效内存
    if (m_files.isEmpty()) {
        return;
    }

    // 验证所有索引的有效性
    for (int index : indices) {
        if (index < 0 || index >= m_files.size()) {
            return;
        }
    }
    // 清理缓存并取消后台任务
    for (int index : indices) {
        const UnifiedFileInfo& fileInfo = m_files[index];
        if (!fileInfo.filePath.isEmpty()) {
            // === 关键补充：取消该文件的后台处理任务 ===
            if (!fileInfo.fileIdentity.isEmpty()) {
                cancelWorkerForFile(fileInfo.fileIdentity);
            }
            
            // === Martin Fowler重构：使用文件级缓存路径清理 ===
            UnifiedCacheManager* cacheManager = UnifiedCacheManager::instance();
            if (cacheManager) {
                cacheManager->clearFileCacheWithFileInfo(fileInfo);
            }
            // === Martin Fowler重构：移除全局页码映射 ===
            removeGlobalPageMapping(fileInfo.fileIdentity);
            // === 补完文件清理机制：清理内存缓存 ===
            MemoryCacheManager* memoryCache = MemoryCacheManager::instance();
            if (memoryCache) {
                memoryCache->clearFileCache(fileInfo.fileIdentity);
            }
            // === 补完文件清理机制：清理布局状态记录 ===
            LayoutStateManager* layoutManager = LayoutStateManager::instance();
            if (layoutManager) {
                layoutManager->removeFileState(fileInfo.fileIdentity);
            }
        }
        emit fileRemoved(index);
    }
    // === Martin Fowler重构：Extract Method - 使用统一的当前索引调整策略 ===
    int newCurrentIndex = calculateNewCurrentIndexAfterDeletion(indices, m_currentIndex);
    // 创建新的文件列表，排除要删除的索引
    QList<UnifiedFileInfo> newFiles;
    QSet<int> indicesToDelete(indices.begin(), indices.end());
    for (int i = 0; i < m_files.size(); ++i) {
        if (!indicesToDelete.contains(i)) {
            newFiles.append(m_files[i]);
        }
    }
    // 更新文件列表
    m_files = newFiles;
    // === 重新分配displayOrder以确保连续性 ===
    for (int i = 0; i < m_files.size(); ++i) {
        m_files[i].displayOrder = i;
    }
    // === Martin Fowler重构：使用统一的索引调整策略 ===
    m_currentIndex = newCurrentIndex;
    m_mainWindowCurrentFile = m_currentIndex; // 同步主窗口当前文件状态
    // === 关键修复：删除操作后应该单选，不保持多选状态 ===
    // 刷新UI以反映文件删除，并确保单选状态
    refreshUIAfterFileDeletion();
    // === Martin Fowler重构：文件删除完成后重新计算全局页码映射 ===
    recalculateGlobalPageMappings();
    emit filesChanged();
    updateTotalDisplayPages(); // 通知总页数变化
    notifyExportAvailability(); // === 关键修复：批量删除后也要通知导出可用性变化 ===
}
void CustomFileBrowser::handleMoveToTop(const QList<int>& indices)
{
    if (indices.isEmpty()) return;
    // === Martin Fowler重构：使用基于位置信息的排序方法 ===
    reorderFilesByPosition(indices, 0);
}
void CustomFileBrowser::handleMoveToBottom(const QList<int>& indices)
{
    if (indices.isEmpty()) return;
    // === Martin Fowler重构：使用基于位置信息的排序方法 ===
    reorderFilesByPosition(indices, m_files.size());
}
void CustomFileBrowser::handleExportSingle(int index)
{
    if (index >= 0 && index < m_files.size()) {
        emit exportRequested();
    }
}
void CustomFileBrowser::handleExportMultiple(const QList<int>& indices)
{
    if (!indices.isEmpty()) {
        emit exportRequested();
    }
}
void CustomFileBrowser::handleExportMerged(const QList<int>& indices)
{
    if (!indices.isEmpty()) {
        emit exportRequested();
    }
}
void CustomFileBrowser::handleSelectAll()
{
    if (m_customFileList) {
        m_customFileList->selectAll();
    }
}
void CustomFileBrowser::handleClearSelection()
{
    if (m_customFileList) {
        m_customFileList->clearSelection();
    }
}

void CustomFileBrowser::handleNaturalSort(const QList<int>& indices)
{

    if (indices.size() < 2) {
        return;
    }

    // 使用基于文件身份的智能排序算法
    applySortOrderByFileIdentity(indices, true);
}

void CustomFileBrowser::handleReverseSort(const QList<int>& indices)
{

    if (indices.size() < 1) {
        return;
    }

    // 使用基于文件身份的智能排序算法，反向模式
    applySortOrderByFileIdentity(indices, false);
}
void CustomFileBrowser::handleDragOperation(const QList<int>& dragIndices, int targetIndex)
{
    // === Martin Fowler重构：使用基于位置信息的排序方法 ===
    reorderFilesByPosition(dragIndices, targetIndex);
}
void CustomFileBrowser::reorderFilesAndUpdateUI(const QList<int>& sourceIndices, int targetIndex)
{
    if (sourceIndices.isEmpty() || targetIndex < 0 || targetIndex > m_files.size()) {
        return;
    }
    // 验证源索引的有效性
    for (int index : sourceIndices) {
        if (index < 0 || index >= m_files.size()) {
            return;
        }
    }
    // 按倒序排列源索引，避免移动时索引变化
    QList<int> sortedSourceIndices = sourceIndices;
    std::sort(sortedSourceIndices.begin(), sortedSourceIndices.end(), std::greater<int>());
    // 提取要移动的文件
    QList<UnifiedFileInfo> movedFiles;
    for (int index : sortedSourceIndices) {
        movedFiles.prepend(m_files[index]);
    }
    // 从原位置移除文件
    for (int index : sortedSourceIndices) {
        m_files.removeAt(index);
    }
    // 调整目标索引（因为删除了前面的文件）
    int adjustedTargetIndex = targetIndex;
    for (int index : sortedSourceIndices) {
        if (index < targetIndex) {
            adjustedTargetIndex--;
        }
    }
    // 在目标位置插入文件
    for (int i = 0; i < movedFiles.size(); ++i) {
        m_files.insert(adjustedTargetIndex + i, movedFiles[i]);
    }
    // === Martin Fowler重构：简化的数据同步逻辑 ===
    // 新架构下，UI会从CustomFileBrowser获取数据，无需复杂的同步逻辑
    // 刷新UI以反映重排序
    m_customFileList->refreshUI(QList<int>());
    emit filesReordered();
    // === Martin Fowler重构：文件重排序完成后重新计算全局页码映射 ===
    recalculateGlobalPageMappings();
}
void CustomFileBrowser::reorderFilesByPosition(const QList<int>& sourceIndices, int targetIndex)
{
    if (sourceIndices.isEmpty() || targetIndex < 0 || targetIndex > m_files.size()) {
        return;
    }

    // 添加内存安全检查
    const int MAX_FILES_FOR_REORDER = 10000;
    if (m_files.size() > MAX_FILES_FOR_REORDER) {
        qWarning() << "文件数量过多，跳过拖拽排序操作以避免内存溢出";
        return;
    }

    // 验证源索引的有效性
    for (int index : sourceIndices) {
        if (index < 0 || index >= m_files.size()) {
            return;
        }
    }

    // === 内存优化重构：使用高效的displayOrder重新分配 ===
    // 创建displayOrder映射，避免创建大型临时列表
    QVector<int> newDisplayOrders(m_files.size());

    // 初始化所有文件的新displayOrder
    for (int i = 0; i < m_files.size(); ++i) {
        newDisplayOrders[i] = i;
    }

    // 处理拖拽操作：调整displayOrder而不移动实际数据
    QList<int> sortedIndices = sourceIndices;
    std::sort(sortedIndices.begin(), sortedIndices.end());

    // 计算目标位置的调整值
    int adjustedTarget = targetIndex;
    for (int sourceIndex : sortedIndices) {
        if (sourceIndex < targetIndex) {
            adjustedTarget--;
        }
    }
    adjustedTarget = qMax(0, adjustedTarget);

    // 重新分配displayOrder - 高效方法
    int nextPos = adjustedTarget;
    for (int sourceIndex : sortedIndices) {
        newDisplayOrders[sourceIndex] = nextPos++;
    }

    // 调整其他文件的displayOrder
    int pos = 0;
    for (int i = 0; i < m_files.size(); ++i) {
        if (!sourceIndices.contains(i)) {
            while (pos >= adjustedTarget && pos < adjustedTarget + sourceIndices.size()) {
                pos++;
            }
            if (pos < m_files.size()) {
                newDisplayOrders[i] = pos++;
            }
        }
    }

    // 应用新的displayOrder
    for (int i = 0; i < m_files.size(); ++i) {
        m_files[i].displayOrder = newDisplayOrders[i];
    }
    // === 内存优化：直接使用displayOrder计算新位置，避免排序和搜索 ===
    int originalCurrentIndex = m_currentIndex;

    // 更新当前索引 - 直接使用displayOrder
    if (m_currentIndex >= 0 && m_currentIndex < m_files.size()) {
        int currentDisplayOrder = m_files[m_currentIndex].displayOrder;
        m_currentIndex = currentDisplayOrder;
    }

    // 计算被拖拽文件的新位置 - 直接使用displayOrder
    QList<int> newPositions;
    newPositions.reserve(sourceIndices.size()); // 预分配内存
    for (int sourceIndex : sourceIndices) {
        if (sourceIndex >= 0 && sourceIndex < m_files.size()) {
            newPositions.append(m_files[sourceIndex].displayOrder);
        }
    }
    std::sort(newPositions.begin(), newPositions.end());
    // 延迟UI刷新，避免在拖拽事件处理过程中重建UI
    if (m_currentIndex >= 0 && m_currentIndex < m_files.size()) {
    }
    // 使用QTimer::singleShot延迟刷新，确保当前事件处理完成
    QTimer::singleShot(0, this, [this, newPositions]() {
        refreshUIByPosition(newPositions);
    });
    // 检查当前文件是否在被拖拽的文件中（使用拖拽排序前的原始索引）
    bool currentFileInDraggedFiles = false;
    if (originalCurrentIndex >= 0 && originalCurrentIndex < m_files.size()) {
        QString currentFilePath = m_files[originalCurrentIndex].filePath;
        for (int sourceIndex : sourceIndices) {
            if (sourceIndex >= 0 && sourceIndex < m_files.size()) {
                if (m_files[sourceIndex].filePath == currentFilePath) {
                    currentFileInDraggedFiles = true;
                    break;
                }
            }
        }
    }
    if (currentFileInDraggedFiles) {
    } else {
        emit filesReordered();
    }
    // === Martin Fowler重构：文件排序完成后重新计算全局页码映射 ===
    recalculateGlobalPageMappings();
}
// === Martin Fowler重构：删除操作专用的UI刷新方法 ===
void CustomFileBrowser::refreshUIAfterFileDeletion()
{
    // 先清除所有选择状态，避免竞态条件
    m_customFileList->clearSelection();

    // 刷新UI组件
    m_customFileList->refreshUI(QList<int>());

    // 安全地更新选择状态
    if (m_currentIndex >= 0 && m_currentIndex < m_files.size() && !m_files.isEmpty()) {
        // 确保文件列表不为空且索引有效
        m_customFileList->updateSelection(m_currentIndex, false); // 不发送信号，避免重复
        // 手动发送单选信号
        emit selectionChanged(QList<int>() << m_currentIndex);
        // 通知主窗口显示当前选中的文件
        emit fileSelected(m_currentIndex, m_files[m_currentIndex]);
    } else {
        // 如果没有有效文件，确保清除所有状态
        m_currentIndex = -1;
        m_mainWindowCurrentFile = -1;
        emit selectionChanged(QList<int>());
    }
}
void CustomFileBrowser::refreshUIByPosition(const QList<int>& draggedNewPositions)
{
    // === Martin Fowler重构：同步数据并重新排列UI元素 ===
    // 先同步CustomFileListWidget的数据，确保displayOrder是最新的
    for (int i = 0; i < m_files.size(); ++i) {
    }
    // === 关键修复：按displayOrder对m_files排序，确保数据和UI顺序一致 ===
    std::sort(m_files.begin(), m_files.end(), [](const UnifiedFileInfo& a, const UnifiedFileInfo& b) {
        return a.displayOrder < b.displayOrder;
    });
    // 在调用refreshUI前记录当前状态
    if (m_currentIndex >= 0 && m_currentIndex < m_files.size()) {
    } else {
    }
    // 重新计算拖拽文件在排序后列表中的正确位置
    QList<int> correctNewPositions = draggedNewPositions; // 直接使用传入的位置，这些已经是正确的新位置
    // 验证位置有效性并打印对应文件
    for (int pos : correctNewPositions) {
        if (pos >= 0 && pos < m_files.size()) {
        } else {
        }
    }
    // 刷新UI以反映新的排序（拖拽排序后不发送信号，避免页面重画）
    m_customFileList->refreshUI(correctNewPositions);
}
// Martin Fowler重构：移除重复的右键菜单槽函数
// 这些功能已经由CustomFileListWidget的FileListContextMenu实现
// 遵循DRY原则，避免重复代码
// Martin Fowler重构：移除重复的移动功能
// 这些功能已经由CustomFileListWidget的FileListContextMenu实现
// Martin Fowler重构：移除重复的移动功能
// 这些功能已经由CustomFileListWidget的FileListContextMenu实现
// Martin Fowler重构：移除重复的导出功能
// 这些功能已经由CustomFileListWidget的FileListContextMenu实现
// 布局模式变更处理槽函数（复刻原FileBrowser行为）
void CustomFileBrowser::onLayoutModeChanged(const QString& fileIdentity, LayoutMode mode)
{
    // 查找对应的文件索引并更新显示
    int index = getFileIndexByIdentity(fileIdentity);
    if (index >= 0) {
        // 同步更新FileInfo（保持兼容性）
        LayoutMode oldLayoutMode = m_files[index].layoutMode;
        m_files[index].layoutMode = static_cast<LayoutMode>(LayoutStateManager::convertToOldLayoutMode(mode));
        
        
        // 更新显示
        updateFileDisplayAt(index);
        
        // === 关键修复：布局模式变化时必须重新计算全局页码映射 ===
        // 因为displayPages会变化（如36页在单列是36，在双列是9）
        recalculateGlobalPageMappings();
        
        // 通知总页数变化
        updateTotalDisplayPages();
    } else {
    }
}
void CustomFileBrowser::onDisplayRefreshNeeded(const QString& fileIdentity)
{
    if (fileIdentity.isEmpty()) {
        // 刷新所有文件显示（工具栏切换布局时触发）
        for (int i = 0; i < m_files.size(); ++i) {
            updateFileDisplayAt(i);
        }
    } else {
        // 刷新指定文件显示
        int index = getFileIndexByIdentity(fileIdentity);
        if (index >= 0) {
            updateFileDisplayAt(index);
        } else {
        }
    }
}
// 私有辅助方法
UnifiedFileInfo CustomFileBrowser::createFileInfo(const QString& filePath)
{
    UnifiedFileInfo info;
    QFileInfo fileInfo(filePath);
    info.filePath = filePath;
    info.fileName = fileInfo.fileName();
    info.fileSize = fileInfo.size();
    info.lastModified = fileInfo.lastModified();
    
    info.pageCount = 1; // 默认页数，后续会更新
    info.fileType = determineFileType(filePath);
    // 生成文件标识（与原FileBrowser保持一致）
    info.fileIdentity = FileIdentityManager::getFileIdentity(filePath);
    
    // === 关键修复：新文件使用系统配置的默认布局 ===
    // 从SystemConfig读取默认布局（图片默认TwoColumns，PDF默认SingleColumn）
    SystemConfig sysConfig = SystemConfigManager::instance().getConfig();
    LayoutMode defaultMode = LayoutStateManager::getDefaultLayoutModeWithConfig(filePath, sysConfig, 0, 0);
    info.layoutMode = static_cast<LayoutMode>(LayoutStateManager::convertToOldLayoutMode(defaultMode));
    
    // 注册到LayoutStateManager（Single Source of Truth）
    LayoutStateManager::instance()->setFileLayoutMode(info.fileIdentity, defaultMode);
    
    
    return info;
}
QString CustomFileBrowser::generateFileIdentity(const QString& filePath) const
{
    // 使用与原FileBrowser相同的文件标识生成方式
    return FileIdentityManager::getFileIdentity(filePath);
}
void CustomFileBrowser::resetToInitialState()
{
    // 重置所有状态变量
    m_currentIndex = -1;
    m_mainWindowCurrentFile = -1;
    // 清空文件列表
    m_files.clear();
    m_customFileList->refreshUI(QList<int>());
    // 清除选择状态
    m_customFileList->clearSelection();
    // 发出清空信号，通知主窗口重置
    emit clearAllRequested();
}
// 辅助方法：确定文件类型
FileType CustomFileBrowser::determineFileType(const QString& filePath) const
{
    QString extension = QFileInfo(filePath).suffix().toLower();
    if (extension == "pdf") {
        return FileType::PDF;
    } else {
        return FileType::Image;
    }
}
// 计算总的显示页数（考虑布局模式）
int CustomFileBrowser::getTotalDisplayPages() const
{
    int totalPages = 0;
    for (const UnifiedFileInfo& fileInfo : m_files) {
        // 获取基础页数（优先使用缓存页数）
        int basePageCount = fileInfo.cachedPageCount > 0 ? fileInfo.cachedPageCount : fileInfo.pageCount;
        if (basePageCount <= 0) {
            basePageCount = 1; // 至少算1页
        }
        // 根据文件的布局模式计算显示页数
        LayoutMode mode = LayoutStateManager::convertFromOldLayoutMode(
            UnifiedFileInfo::layoutModeToInt(fileInfo.layoutMode));
        int displayPages = LayoutStateManager::calculateDisplayPages(mode, basePageCount);
        totalPages += displayPages;
    }
    return totalPages;
}
// 更新总页数并发出信号
void CustomFileBrowser::updateTotalDisplayPages()
{
    int totalPages = getTotalDisplayPages();
    emit totalDisplayPagesChanged(totalPages);
}
// === Martin Fowler重构：全局页码连续性支持 ===
void CustomFileBrowser::updateGlobalPageMapping(const QString& fileIdentity, int displayPages)
{
    GlobalPageManager& globalPageManager = GlobalPageManager::instance();
    globalPageManager.updateFileInfo(fileIdentity, displayPages);
    // 确保文件顺序与文件浏览器中的顺序一致
    ensureGlobalFileOrder();
}
void CustomFileBrowser::removeGlobalPageMapping(const QString& fileIdentity)
{
    GlobalPageManager& globalPageManager = GlobalPageManager::instance();
    globalPageManager.removeFileInfo(fileIdentity);
}
void CustomFileBrowser::ensureGlobalFileOrder()
{
    // 简单实现：调用recalculateGlobalPageMappings来确保顺序正确
    // 这个方法已经包含了正确的排序逻辑
    recalculateGlobalPageMappings();
}
void CustomFileBrowser::recalculateGlobalPageMappings()
{
    
    GlobalPageManager& globalPageManager = GlobalPageManager::instance();
    // === Martin Fowler分析：确保文件顺序与UI显示顺序一致 ===
    // 创建一个按displayOrder排序的文件列表
    QList<UnifiedFileInfo> sortedFiles = m_files;
    std::sort(sortedFiles.begin(), sortedFiles.end(), [](const UnifiedFileInfo& a, const UnifiedFileInfo& b) {
        return a.displayOrder < b.displayOrder;
    });
    
    // === 关键修复：所有layoutMode都从LayoutStateManager读取 ===
    
    for (int i = 0; i < sortedFiles.size(); ++i) {
        const UnifiedFileInfo& fileInfo = sortedFiles[i];
        int basePageCount = fileInfo.cachedPageCount > 0 ? fileInfo.cachedPageCount : fileInfo.pageCount;
        
        // 强制从LayoutStateManager读取（Single Source of Truth）
        LayoutMode mode = LayoutStateManager::instance()->getFileLayoutMode(fileInfo.fileIdentity);
        int displayPages = LayoutStateManager::calculateDisplayPages(mode, basePageCount);
        
    }
    
    // 清空现有映射
    globalPageManager.clearAllFileInfo();
    
    // === 关键修复：按UI显示顺序（displayOrder）重新添加映射 ===
    for (int i = 0; i < sortedFiles.size(); ++i) {
        const UnifiedFileInfo& fileInfo = sortedFiles[i];
        // 计算显示页数
        int basePageCount = fileInfo.cachedPageCount > 0 ? fileInfo.cachedPageCount : fileInfo.pageCount;
        if (basePageCount <= 0) {
            basePageCount = 1;
        }
        
        // 与上面的调试循环使用完全一致的逻辑
        LayoutMode mode = LayoutStateManager::instance()->getFileLayoutMode(fileInfo.fileIdentity);
        int displayPages = LayoutStateManager::calculateDisplayPages(mode, basePageCount);
        
        // 添加到全局页码管理器
        globalPageManager.updateFileInfo(fileInfo.fileIdentity, displayPages);
    }
    // 触发页码映射重新计算
    globalPageManager.recalculatePageMappings();
    
}

// Martin Fowler重构：导出可用性检查和通知（简化Observer模式）
bool CustomFileBrowser::checkExportAvailability() const
{

    if (m_files.isEmpty()) {
        return false;
    }

    // 检查所有文件是否都已处理完成（缓存完成）
    for (const UnifiedFileInfo& fileInfo : m_files) {
        if (fileInfo.processStatus != FileProcessStatus::Completed) {
            return false;
        }
    }

    return true;
}

void CustomFileBrowser::notifyExportAvailability()
{
    bool available = checkExportAvailability();
    emit exportAvailabilityChanged(available);
}

void CustomFileBrowser::applySortOrderByFileIdentity(const QList<int>& indices, bool naturalSort)
{

    // 1. 收集要排序的文件信息（包含处理状态）
    struct SortableFile {
        QString fileIdentity;
        UnifiedFileInfo fileInfo;
        int originalDisplayOrder;
        QString extractedNumber;
        qint64 numberValue;
    };

    QList<SortableFile> sortableFiles;
    QList<int> targetDisplayOrders;

    for (int index : indices) {
        if (index >= 0 && index < m_files.size()) {
            SortableFile sf;
            sf.fileIdentity = m_files[index].fileIdentity;
            sf.fileInfo = m_files[index];
            sf.originalDisplayOrder = m_files[index].displayOrder;

            // 提取数字用于排序
            QRegularExpression numberRegex(R"(\d+)");
            QRegularExpressionMatch match = numberRegex.match(m_files[index].fileName);
            if (match.hasMatch()) {
                sf.extractedNumber = match.captured(0);
                sf.numberValue = sf.extractedNumber.toLongLong();
            } else {
                sf.extractedNumber = "";
                sf.numberValue = 0;
            }

            sortableFiles.append(sf);
            targetDisplayOrders.append(sf.originalDisplayOrder);
        }
    }

    // 2. 排序文件信息
    if (naturalSort) {
        std::sort(sortableFiles.begin(), sortableFiles.end(),
                  [](const SortableFile& a, const SortableFile& b) {
                      return a.numberValue < b.numberValue;
                  });
    } else {
        // 反向排序：按原始displayOrder倒序
        std::sort(sortableFiles.begin(), sortableFiles.end(),
                  [](const SortableFile& a, const SortableFile& b) {
                      return a.originalDisplayOrder > b.originalDisplayOrder;
                  });
    }

    // 3. 按排序后的顺序重新分配到目标位置
    std::sort(targetDisplayOrders.begin(), targetDisplayOrders.end());

    for (int i = 0; i < sortableFiles.size() && i < targetDisplayOrders.size(); ++i) {
        int targetDisplayOrder = targetDisplayOrders[i];

        // 找到对应的文件在当前列表中的位置
        for (int j = 0; j < m_files.size(); ++j) {
            if (m_files[j].displayOrder == targetDisplayOrder) {
                // 更新文件信息，保持所有状态（包括处理状态）
                m_files[j] = sortableFiles[i].fileInfo;
                m_files[j].displayOrder = targetDisplayOrder;

                break;
            }
        }
    }

    // 4. 更新UI和重新计算映射
    if (m_customFileList) {
        m_customFileList->refreshUI(QList<int>());
    }
    recalculateGlobalPageMappings();
    emit filesReordered();

}

void CustomFileBrowser::applySortedOrder(const QList<int>& originalIndices, const QList<int>& sortedIndices)
{

    if (originalIndices.size() != sortedIndices.size()) {
        return;
    }

    // 使用与reorderFilesByPosition相同的方法：只修改displayOrder
    // 1. 创建排序后的虚拟文件列表（按照排序结果）
    QList<UnifiedFileInfo> tempFiles;
    for (int i = 0; i < sortedIndices.size(); ++i) {
        int sourceIndex = sortedIndices[i];
        if (sourceIndex >= 0 && sourceIndex < m_files.size()) {
            tempFiles.append(m_files[sourceIndex]);
        }
    }

    // 2. 更新被排序文件的displayOrder - 按排序后的顺序放置
    QList<int> sortedOriginalIndices = originalIndices;
    std::sort(sortedOriginalIndices.begin(), sortedOriginalIndices.end());

    for (int i = 0; i < tempFiles.size(); ++i) {
        if (i < sortedOriginalIndices.size()) {
            int targetIndex = sortedOriginalIndices[i];  // 按顺序放置的位置
            if (targetIndex >= 0 && targetIndex < m_files.size()) {
                int newDisplayOrder = targetIndex;  // 使用位置作为新的displayOrder

                // 替换这个位置的文件内容
                m_files[targetIndex] = tempFiles[i];
                m_files[targetIndex].displayOrder = newDisplayOrder;  // 确保displayOrder正确
            }
        }
    }

    // 3. 更新UI显示
    if (m_customFileList) {
        m_customFileList->refreshUI(QList<int>());
    }

    // 4. 重新计算全局页码映射
    recalculateGlobalPageMappings();

    // 5. 发出文件重排序信号
    emit filesReordered();

    // 6. 更新总页数
    updateTotalDisplayPages();
}